
package capa_logica;

public abstract class Actor
{
    static int TAM_CELDA = 5;
    
    int posicionX;
    int posicionY;
    int energia;
    int vision;
    int velocidad;
    int largo;
    int ancho;
    int orientacion; //Entero entre 0 y 359 que marca el angulo con respecto al NORTE.
    //Por ejemplo orientacion igual 90, el actor mira hacia el ESTE.
    Escenario e;
    
    //clase abtrassvdv
    public Actor(int X, int Y, int ene, int vis, int vel, int lar, int anc, int ori, Escenario esc)
    {
        posicionX = X;
        posicionY = Y;
        energia = ene;
        vision = vis;
        velocidad = vel;
        largo = lar;
        ancho = anc;
        orientacion = ori;
        e = esc;
    }
    
    public void eliminarActor()
    {
        energia = 0;
        velocidad = 0;
        vision = 0;
    }
    
    public void avanzar(char codigo)
    {
        if(orientacion == 0)
        {
            if(((posicionY - velocidad) / TAM_CELDA) != ((posicionY) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), (posicionY - velocidad) / TAM_CELDA) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (ancho / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY - velocidad) / TAM_CELDA), codigo);
                        e.liberarCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY + largo - velocidad) / TAM_CELDA));
                        i++;
                    }
                    posicionY = posicionY - velocidad;
                }
            }
            else if((posicionY - velocidad) >= 0)//Si no cambio de celda con el movimiento
            {
                posicionY = posicionY - velocidad;
            }
        }
        else if(orientacion == 90)
        {
            if(((posicionX + velocidad) / TAM_CELDA) != ((posicionX) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX + largo) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA)) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (ancho / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX + largo) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA), codigo);
                        e.liberarCelda(((posicionX) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA));
                        i++;
                    }
                    posicionX = posicionX + velocidad;
                }
            }
            else if((posicionX + velocidad) <= e.getLargo())
            {
                posicionX = posicionX + velocidad;
            }
            
        }
        else if(orientacion == 180)
        {
            if(((posicionY + velocidad) / TAM_CELDA) != ((posicionY) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX  + (TAM_CELDA * i)) / TAM_CELDA), (((posicionY + largo) / TAM_CELDA))) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (ancho / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX  + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY + largo) / TAM_CELDA), codigo);
                        e.liberarCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY) / TAM_CELDA));
                        i++;
                    }
                    posicionY = posicionY + velocidad;
                }
            }
            else if((posicionY + velocidad) <= e.getAncho())
            {
                posicionY = posicionY + velocidad;
            }
            
        }
        else if(orientacion == 270)
        {
            if(((posicionX - velocidad) / TAM_CELDA) != ((posicionX) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX - velocidad) / TAM_CELDA), (((posicionY + (TAM_CELDA * i)) / TAM_CELDA))) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (ancho / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX - velocidad) / TAM_CELDA), (((posicionY + (TAM_CELDA * i)) / TAM_CELDA)), codigo);
                        e.liberarCelda(((posicionX + largo - velocidad) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA));
                        i++;
                    }
                    posicionX = posicionX - velocidad;
                }
            }
            else if((posicionX - velocidad) >= 0)
            {
                posicionX = posicionX - velocidad;
            }
        }
        else if(orientacion == 45)
        {
            if(((posicionY - velocidad) / TAM_CELDA) != ((posicionY) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), (posicionY - velocidad) / TAM_CELDA) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (largo / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY - velocidad) / TAM_CELDA), codigo);
                        e.liberarCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY + largo - velocidad) / TAM_CELDA));
                        i++;
                    }
                    posicionY = posicionY - velocidad;
                }
            }
            else if((posicionY - velocidad) >= 0)//Si no cambio de celda con el movimiento
            {
                posicionY = posicionY - velocidad;
            }
            
            
            if(((posicionX + velocidad) / TAM_CELDA) != ((posicionX) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX + largo) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA)) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (largo / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX + largo) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA), codigo);
                        e.liberarCelda(((posicionX) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA));
                        i++;
                    }
                    posicionX = posicionX + velocidad;
                }
            }
            else if((posicionX + velocidad) <= e.getLargo())
            {
                posicionX = posicionX + velocidad;
            }
            
        }
        else if(orientacion == 135)
        {
            if(((posicionX + velocidad) / TAM_CELDA) != ((posicionX) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX + largo) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA)) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (largo / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX + largo) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA), codigo);
                        e.liberarCelda(((posicionX) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA));
                        i++;
                    }
                    posicionX = posicionX + velocidad;
                }
            }
            else if((posicionX + velocidad) <= e.getLargo())
            {
                posicionX = posicionX + velocidad;
            }
            
            if(((posicionY + velocidad) / TAM_CELDA) != ((posicionY) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX  + (TAM_CELDA * i)) / TAM_CELDA), (((posicionY + largo) / TAM_CELDA))) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (largo / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX  + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY + largo) / TAM_CELDA), codigo);
                        e.liberarCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY) / TAM_CELDA));
                        i++;
                    }
                    posicionY = posicionY + velocidad;
                }
            }
            else if((posicionY + velocidad) <= e.getAncho())
            {
                posicionY = posicionY + velocidad;
            }
            
        }
        else if(orientacion == 225)
        {
            if(((posicionY + velocidad) / TAM_CELDA) != ((posicionY) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX  + (TAM_CELDA * i)) / TAM_CELDA), (((posicionY + largo) / TAM_CELDA))) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (largo / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX  + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY + largo) / TAM_CELDA), codigo);
                        e.liberarCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY) / TAM_CELDA));
                        i++;
                    }
                    posicionY = posicionY + velocidad;
                }
            }
            else if((posicionY + velocidad) <= e.getAncho())
            {
                posicionY = posicionY + velocidad;
            }
            
            if(((posicionX - velocidad) / TAM_CELDA) != ((posicionX) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX - velocidad) / TAM_CELDA), (((posicionY + (TAM_CELDA * i)) / TAM_CELDA))) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (largo / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX - velocidad) / TAM_CELDA), (((posicionY + (TAM_CELDA * i)) / TAM_CELDA)), codigo);
                        e.liberarCelda(((posicionX + largo - velocidad) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA));
                        i++;
                    }
                    posicionX = posicionX - velocidad;
                }
            }
            else if((posicionX - velocidad) >= 0)
            {
                posicionX = posicionX - velocidad;
            }
        }
        else if(orientacion == 315)
        {
            if(((posicionX - velocidad) / TAM_CELDA) != ((posicionX) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX - velocidad) / TAM_CELDA), (((posicionY + (TAM_CELDA * i)) / TAM_CELDA))) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (largo / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX - velocidad) / TAM_CELDA), (((posicionY + (TAM_CELDA * i)) / TAM_CELDA)), codigo);
                        e.liberarCelda(((posicionX + largo - velocidad) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA));
                        i++;
                    }
                    posicionX = posicionX - velocidad;
                }
            }
            else if((posicionX - velocidad) >= 0)
            {
                posicionX = posicionX - velocidad;
            }
            
            if(((posicionY - velocidad) / TAM_CELDA) != ((posicionY) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), (posicionY - velocidad) / TAM_CELDA) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (largo / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY - velocidad) / TAM_CELDA), codigo);
                        e.liberarCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY + largo - velocidad) / TAM_CELDA));
                        i++;
                    }
                    posicionY = posicionY - velocidad;
                }
            }
            else if((posicionY - velocidad) >= 0)//Si no cambio de celda con el movimiento
            {
                posicionY = posicionY - velocidad;
            }
        }
    }
    
    public void retroceder(char codigo)
    {
        if(orientacion == 180)
        {
            if(((posicionY - velocidad) / TAM_CELDA) != ((posicionY) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), (posicionY - velocidad) / TAM_CELDA) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (ancho / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY - velocidad) / TAM_CELDA), codigo);
                        e.liberarCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY + largo - velocidad) / TAM_CELDA));
                        i++;
                    }
                    posicionY = posicionY - velocidad;
                }
            }
            else if((posicionY - velocidad) >= 0)//Si no cambio de celda con el movimiento
            {
                posicionY = posicionY - velocidad;
            }
        }
        else if(orientacion == 270)
        {
            if(((posicionX + velocidad) / TAM_CELDA) != ((posicionX) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX + largo) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA)) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (ancho / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX + largo) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA), codigo);
                        e.liberarCelda(((posicionX) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA));
                        i++;
                    }
                    posicionX = posicionX + velocidad;
                }
            }
            else if((posicionX + velocidad) <= e.getLargo())
            {
                posicionX = posicionX + velocidad;
            }
            
        }
        else if(orientacion == 0)
        {
            if(((posicionY + velocidad) / TAM_CELDA) != ((posicionY) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX  + (TAM_CELDA * i)) / TAM_CELDA), (((posicionY + largo) / TAM_CELDA))) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (ancho / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX  + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY + largo) / TAM_CELDA), codigo);
                        e.liberarCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY) / TAM_CELDA));
                        i++;
                    }
                    posicionY = posicionY + velocidad;
                }
            }
            else if((posicionY + velocidad) <= e.getAncho())
            {
                posicionY = posicionY + velocidad;
            }
            
        }
        else if(orientacion == 90)
        {
            if(((posicionX - velocidad) / TAM_CELDA) != ((posicionX) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX - velocidad) / TAM_CELDA), (((posicionY + (TAM_CELDA * i)) / TAM_CELDA))) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (ancho / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX - velocidad) / TAM_CELDA), (((posicionY + (TAM_CELDA * i)) / TAM_CELDA)), codigo);
                        e.liberarCelda(((posicionX + largo - velocidad) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA));
                        i++;
                    }
                    posicionX = posicionX - velocidad;
                }
            }
            else if((posicionX - velocidad) >= 0)
            {
                posicionX = posicionX - velocidad;
            }
        }
        else if(orientacion == 225)
        {
            if(((posicionY - velocidad) / TAM_CELDA) != ((posicionY) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), (posicionY - velocidad) / TAM_CELDA) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (largo / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY - velocidad) / TAM_CELDA), codigo);
                        e.liberarCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY + largo - velocidad) / TAM_CELDA));
                        i++;
                    }
                    posicionY = posicionY - velocidad;
                }
            }
            else if((posicionY - velocidad) >= 0)//Si no cambio de celda con el movimiento
            {
                posicionY = posicionY - velocidad;
            }
            
            
            if(((posicionX + velocidad) / TAM_CELDA) != ((posicionX) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX + largo) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA)) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (largo / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX + largo) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA), codigo);
                        e.liberarCelda(((posicionX) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA));
                        i++;
                    }
                    posicionX = posicionX + velocidad;
                }
            }
            else if((posicionX + velocidad) <= e.getLargo())
            {
                posicionX = posicionX + velocidad;
            }
            
        }
        else if(orientacion == 315)
        {
            if(((posicionX + velocidad) / TAM_CELDA) != ((posicionX) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX + largo) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA)) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (largo / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX + largo) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA), codigo);
                        e.liberarCelda(((posicionX) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA));
                        i++;
                    }
                    posicionX = posicionX + velocidad;
                }
            }
            else if((posicionX + velocidad) <= e.getLargo())
            {
                posicionX = posicionX + velocidad;
            }
            
            if(((posicionY + velocidad) / TAM_CELDA) != ((posicionY) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX  + (TAM_CELDA * i)) / TAM_CELDA), (((posicionY + largo) / TAM_CELDA))) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (largo / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX  + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY + largo) / TAM_CELDA), codigo);
                        e.liberarCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY) / TAM_CELDA));
                        i++;
                    }
                    posicionY = posicionY + velocidad;
                }
            }
            else if((posicionY + velocidad) <= e.getAncho())
            {
                posicionY = posicionY + velocidad;
            }
            
        }
        else if(orientacion == 45)
        {
            if(((posicionY + velocidad) / TAM_CELDA) != ((posicionY) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX  + (TAM_CELDA * i)) / TAM_CELDA), (((posicionY + largo) / TAM_CELDA))) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (largo / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX  + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY + largo) / TAM_CELDA), codigo);
                        e.liberarCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY) / TAM_CELDA));
                        i++;
                    }
                    posicionY = posicionY + velocidad;
                }
            }
            else if((posicionY + velocidad) <= e.getAncho())
            {
                posicionY = posicionY + velocidad;
            }
            
            if(((posicionX - velocidad) / TAM_CELDA) != ((posicionX) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX - velocidad) / TAM_CELDA), (((posicionY + (TAM_CELDA * i)) / TAM_CELDA))) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (largo / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX - velocidad) / TAM_CELDA), (((posicionY + (TAM_CELDA * i)) / TAM_CELDA)), codigo);
                        e.liberarCelda(((posicionX + largo - velocidad) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA));
                        i++;
                    }
                    posicionX = posicionX - velocidad;
                }
            }
            else if((posicionX - velocidad) >= 0)
            {
                posicionX = posicionX - velocidad;
            }
        }
        else if(orientacion == 135)
        {
            if(((posicionX - velocidad) / TAM_CELDA) != ((posicionX) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX - velocidad) / TAM_CELDA), (((posicionY + (TAM_CELDA * i)) / TAM_CELDA))) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (largo / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX - velocidad) / TAM_CELDA), (((posicionY + (TAM_CELDA * i)) / TAM_CELDA)), codigo);
                        e.liberarCelda(((posicionX + largo - velocidad) / TAM_CELDA), ((posicionY + (TAM_CELDA * i)) / TAM_CELDA));
                        i++;
                    }
                    posicionX = posicionX - velocidad;
                }
            }
            else if((posicionX - velocidad) >= 0)
            {
                posicionX = posicionX - velocidad;
            }
            
            if(((posicionY - velocidad) / TAM_CELDA) != ((posicionY) / TAM_CELDA)) //Si cambio de celda
            {
                int i = 0;
                boolean disponible = true;
                while(i < (ancho / TAM_CELDA) && disponible)
                {
                    if(e.proximaCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), (posicionY - velocidad) / TAM_CELDA) != '0')
                    {
                        disponible = false;
                    }
                    i++;
                }
                if(disponible)
                {  
                    i = 0;
                    while(i < (largo / TAM_CELDA))
                    {
                        e.ocuparCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY - velocidad) / TAM_CELDA), codigo);
                        e.liberarCelda(((posicionX + (TAM_CELDA * i)) / TAM_CELDA), ((posicionY + largo - velocidad) / TAM_CELDA));
                        i++;
                    }
                    posicionY = posicionY - velocidad;
                }
            }
            else if((posicionY - velocidad) >= 0)//Si no cambio de celda con el movimiento
            {
                posicionY = posicionY - velocidad;
            }
        }
    }
    
    //Getters y Setters
    
    public int getPosicionX() 
    {
        return posicionX;
    }

    public void setPosicionX(int posicionX) 
    {
        this.posicionX = posicionX;
    }

    public int getPosicionY() 
    {
        return posicionY;
    }

    public void setPosicionY(int posicionY) 
    {
        this.posicionY = posicionY;
    }

    public int getEnergia() 
    {
        return energia;
    }

    public void setEnergia(int energia) 
    {
        this.energia = energia;
    }

    public int getVision() 
    {
        return vision;
    }

    public void setVision(int vision) 
    {
        this.vision = vision;
    }

    public int getVelocidad() 
    {
        return velocidad;
    }

    public void setVelocidad(int velocidad) 
    {
        this.velocidad = velocidad;
    }

    public int getLargo() 
    {
        return largo;
    }

    public void setLargo(int largo) 
    {
        this.largo = largo;
    }

    public int getAncho() 
    {
        return ancho;
    }

    public void setAncho(int ancho) 
    {
        this.ancho = ancho;
    }

    public int getOrientacion() 
    {
        return orientacion;
    }

    public void setOrientacion(int orientacion) 
    {
        this.orientacion = orientacion;
    }   
}
